import java.util.Arrays;

//Arrays 数组的包 里面可以用多组操作数组的方法
public class Test {

    //数组的练习.
    //6.冒泡排序
    public static void bubbleSort(int[] array) {
        //i代表的是趟数
        for (int i = 0; i < array.length-1; i++) {
            boolean flg = false;
            //j代表每一趟比较的次数
            for (int j = 0; j < array.length-1-i; j++) {
                if(array[j] > array[j+1]) {
                    int tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                    flg = true;
                }
            }
            if(flg == false) {
                break;//说明有序了
            }
        }
    }
    public static void main(String[] args) {
        int[] array = {1,2,13,4,15};
        bubbleSort(array);
        System.out.println(Arrays.toString(array));
    }
    //5.
//    public static void main(String[] args) {
//        //equals-- 比较两个数字对应位置数据是否一样 返回值是布尔类型
//        int[] array1 = {1,2,3,4,5,6};
//        int[] array2 = {1,2,3,4,5,6};
//        boolean fla = Arrays.equals(array1, array2);
//        System.out.println(fla);
//        //fill-- 填充数据
//        int[] array3 = new int[10];
//        //Arrays.fill(array3, -1);//把array3里面的值填充为-1
//        //System.out.println(Arrays.toString(array3));
//        Arrays.fill(array3, 1,4, -1);//把array3里面的[1,4)里面的数据填充为-1 其余是0
//        System.out.println(Arrays.toString(array3));
//    }
    //4.查找数组中指定元素
    //二分查找 -- 针对的数组是有序的
//    public static int binarySearch(int[] array, int key) {
//        int left = 0;
//        int right = array.length-1;
//        while(left <= right) {
//            int mid = (left+right) / 2;
//            if(array[mid] < key) {
//                left = mid + 1;
//            } else if(array[mid] > key) {
//                right = mid - 1;
//            }else {
//                return mid;
//            }
//        }
//        return -1;//没找到
//    }
//    public static void main(String[] args) {
//        int[] array = {1,2,13,4,15};
//        Arrays.sort(array);//排有序 -- 升序
//        System.out.println(Arrays.toString(array));
//        System.out.println(binarySearch(array, 13));
//        System.out.println(Arrays.binarySearch(array, 13));//java提供的查找方法--binarySearch
//    }

//    public static int findVal(int[] array, int x) {
//        for (int i = 0; i < array.length; i++) {
//            if(array[i] == x) {
//                return i;//找到了返回下标
//            }
//        }
//        return -1;
//    }
//    public static void main(String[] args) {
//        int[] array = {1,2,3,4,5};
//        System.out.println(findVal(array, 5));
//    }
    //3.求数组元素的平均值
//    public static double avg(int[] array) {
//        int sum = 0;
//        for (int x:array) {
//            sum += x;
//        }
//        return (double)sum/(double)array.length;
//    }
//    public static void main(String[] args) {
//        int[] array = {1,2,3,4,5,6};
//        System.out.println(avg(array));
//    }
    //2.数组拷贝
//    public static void main(String[] args) {
//        int[] array = {1,2,3,4,5};
//        int[] copy = new int[array.length];
//        for (int i = 0; i < array.length; i++) {
//            copy[i] = array[i];
//        }
//        System.out.println(Arrays.toString(copy));
//
//        //这不是拷贝
//        int[] array2 = {1,2,3,4,5};
//        int[] array3 = array2;
//        System.out.println(Arrays.toString(array3));
//
//    }
//    public static void main(String[] args) {
//        int[] array = {1,2,3,4,5};
//        int[] copy = Arrays.copyOf(array, array.length);
//        //copyOf拷贝的方法 第一个参数源数组 第二个参数是拷贝的长度 返回值用数组接收
//        System.out.println(Arrays.toString(copy));
//        copy = Arrays.copyOf(array, array.length*2);
//        //copyOf拷贝的方法 第一个参数源数组 第二个参数是拷贝的长度可以自己设置长度 能够扩容
//        System.out.println(Arrays.toString(copy));
//
//        copy = Arrays.copyOfRange(array, 1, 3);//有范围的拷贝 拷贝array这个数组下标是[1,3)的数据 左闭右开
//                                                         //能拷贝多少拷贝多少 范围大了用0补
//        System.out.println(Arrays.toString(copy));
//
//    }
//    public static void main(String[] args) {
//        int[] array = {1,2,3,4,5};
//        int[] copy = new int[array.length];
//        System.arraycopy(array, 0, copy, 0, array.length);
//        //参数介绍 源数组  源数组开始拷贝的位置(下标) 目标数组 目标数组开始拷贝的位置(下标) 拷贝的长度
//        System.out.println(Arrays.toString(copy));
//    }

    //1.数组转字符串 -- toString
//    public static void main(String[] args) {
//        int[] ret = {1,2,3,4,5,6};
//        String s = Arrays.toString(ret);//toString这个方法把整型数组转化成字符串 返回值是一个字符串类型
//        System.out.println(s);
//        //System.out.println(Arrays.toString(ret));
//    }

    //模拟实现toString
//    public static String myToString(int[] array) {
//        String ret = "[";
//        for (int i = 0; i < array.length; i++) {
//            ret += array[i];
//            if(i<array.length-1){
//                ret += ",";
//            }
//        }
//        ret += "]";
//        return ret;
//    }
//    public static void main(String[] args) {
//        int[] array = {1,2,3,4,5};
//        String s = myToString(array);
//        System.out.println(s);
//    }

    //数组的应用场景
    //作为函数的返回值
    //可以返回整个数组
//    public static int[] func3() {
////        int[] array = {1,2,3,4,5,6};
////        return array;
//        return new int[]{1,2,3,4,5};
//    }
//    public static void main(String[] args) {
//        int[] ret = func3();
//        for (int i = 0; i < ret.length; i++) {
//            System.out.print(ret[i]+" ");
//        }
//    }

    //作为参数
//    public static void func1(int[] array) {
//        array = new int[10];
//    }
//
//    public static void func2(int[] array) {
//        array[0] = 99;//这种情况是通过引用指向的对象来改变对象里面的内容
//        //array = null;//这不影响实参  把形参里面的值改变了 而实参里面的值还是那个值 指向的还是那个对象
//    }
//    public static void main(String[] args) {
//        //作为参数
//        int[] array1 = {1,2,3,4};
//        //把array1的值给了func1函数的array 那么array也就指向了array1这个引用所指向的对象
//        //在func1函数里面array创建了一个数组 那么array就指向了这个新的数组 改变了形参array的指向 和实参没有关系了
//        //所以打印的还是array1里的内容   出了func1函数形参的内容被回收了就
//        //不要以为传引用就能改变实参 这种情况不会影响实参的指向
//        func1(array1);
//        for (int i = 0; i < array1.length; i++) {
//            System.out.print(array1[i]+" ");//1 2 3 4
//        }
//        System.out.println();
//        int[] array2 = {1,2,3,4};
//        //把array2传过去 那么array就是array2的值 array就指向了array2所指向的对象 他俩指向同一个数组对象 array[0] 就相当于array2[0]
//        //这里通过array[0]来修改array2所指向对象下标为0的值 所以这个是 99 2 3 4
//        func2(array2);
//        for (int i = 0; i < array2.length; i++) {
//            System.out.print(array2[i]+" ");//99 2 3 4
//        }
//
//    }

//    public static void main(String[] args) {
//        //null 是java里的空引用
//
//        int[] array3 = null;//代表array3这个引用不指向任何对象
//        System.out.println(array3.length);//不能输出它的长度  会出现空指针异常
//        //null和0地址的内存没有任何关联
//    }

//    public static void main(String[] args) {
//        int[] array1 = new int[3];//array1是一个引用
//        //给array1这个数组里面放数据
//        array1[0] = 10;
//        array1[1] = 20;
//        array1[2] = 30;
//        int[] array2 = new int[]{1,2,3,4,5};//array2也是一个引用
//        //往array2的前两个元素里放值
//        array2[0] = 100;
//        array2[1] = 200;
//        array1 = array2;//array2里面的值给array1  那么array1里的值就是array2  array1和array2所指向的对象就是同一个
//                        //都指向了array2所指向的对象 那么array1刚开始所指向的对象就被回收了
//        //这里其实就是通过array1这个引用来修改array2这个引用所指向的对象 他俩指向了同一个对象 两个都可以修改这个对象
//        array1[2] = 300;
//        array1[3] = 400;
//        array1[4] = 500;
//    }

}
